NAZWA¶

perlsyn - Składnia perla

OPIS¶

Skrypt perla składa się z sekwencji deklaracji i instrukcji. Jedynymi rzeczami, które muszą być zadeklarowane w perlu, to formatki raportowe i procedury. Więcej informacji o tych deklaracji znajdziesz w sekcjach poniżej. Wszystkie niezainicjalizowane, stworzone przez użytkownika obiekty, uznawane są za posiadające początkową wartość null lub 0, dopóki nie zostaną zdefiniowane w jakiejś jawnej operacji, jak np. przypisanie. (Choć jeśli chcesz, możesz dostawać ostrzeżenia o używaniu wartości niezdefiniowanych.) Sekwencja instrukcji jest wykonywana tylko jednokrotnie, w przeciwieństwie do skryptów sed(1) czy awk(1), gdzie sekwencja taka jest wykonywana dla każdej linii wejściowej. Oznacza to, że musisz jawnie przetwarzać w pętli linie swojego pliku wejściowego (lub plików), oznacza to też, że masz dużo większą kontrolę nad tym, którymi plikami i liniami się zajmujesz. (Właściwie to kłamię--można zrobić niejawną pętlę za pomocą przełącznika -n lub -p. Nie jest to po prostu domyślne i zarazem obowiązkowe jak w sed(1) czy awk(1).)

Deklaracje

Perl jest w ogólności językiem wolnej postaci (free-form). (Jedynym wyjątkiem są deklarację formatek--z oczywistych przyczyn.) Komentarze są rozpoczynane znakiem "#" i ciągną się do końca linii. Jeśli spróbujesz użyć komentarzy /* */ w stylu C, to zostaną one zinterpretowane albo jako dzielenie, albo jako porównywanie wzorca. Z kolei komentarz // z C++ wygląda dokładnie jak puste wyrażenie regularne. Nie kombinuj więc z tymi konstrukcjami.

Deklaracja może być wstawiona gdziekolwiek, gdzie można wstawić instrukcję, lecz nie ma wpływu na wykonywanie podstawowej sekwencji instrukcji--deklaracje mają znaczenie tylko podczas kompilacji. Zazwyczaj wszystkie deklaracje wstawiane są na początku lub na końcu skryptu. Jeśli jednak używasz zmiennych prywatnych zawężonych leksykalnie, utworzonych przez my(), będziesz musiał się upewnić, czy twoja definicja formatki lub procedury, używającej tych deklaracji leży wewnątrz tego samego zakresu.

Deklarowanie procedury zezwala na używanie jej nazwy tak, jakby była operatorem listowym, licząc od tego miejsca, aż do końca programu. Możesz zadeklarować procedurę bez jej definiowania, pisząc sub name, więc:

    sub myname;
    $me = myname $0             or die "can't get myname";

Deklaracje procedur mogą być również ładowane instrukcją require, lub jednocześnie ładowane jak i importowane do przestrzeni nazw dzięki instrukcji use. Dla szczegółów polecam podręcznik perlmod(1).

Sekwencja instrukcji może zawierać deklaracje zmiennych zawężonych leksykalnie, lecz poza deklarowaniem nazwy zmiennej, deklaracja działa jak zwykła instrukcja i jest wykonywana w sekwencji instrukcji jak zwyczajna instrukcja. Znaczy to, że ma ona zarówno skutki podczas kompilacji, jak w czasie działania.

Instrukcje proste

Jedynym rodzajem instrukcji prostej jest wyrażenie, analizowane dla swoich efektów ubocznych. Każda instrukcja prosta musi się kończyć średnikiem, chyba że jest ostatnią instrukcją bloku, wtedy średnik nie jest obowiązujący. (Jednak wciąż jest zalecany jeśli blok zajmuje więcej niż jedną linię, gdyż możliwe że dodasz jeszcze kolejne linie.) Zauważ, że istnieją operatory takie, jak eval {} i do {}, które wyglądają jak instrukcje złożone, lecz nimi nie są i wymagają jawnego zakończenia jeśli są użyte jako ostatni element instrukcji.

Za każdą prostą instrukcją, tuż przed średnikiem (lub końcem bloku) może znajdować się POJEDYNCZY modyfikator. Dopuszczalne modyfikatory to:

    if WYRAŻ
    unless WYRAŻ
    while WYRAŻ
    until WYRAŻ
    foreach WYRAŻ

    do {
        $line = <STDIN>;
        ...
    } until $line  eq ".\n";

   do {{
      next if $x == $y;
      # coś tu robi
   }} until $x++ > $z;

   LOOP: {
           do {
              last if $x = $y**2;
              # coś tu robi
           } while $x++ <= $z;
   }

Instrukcje złożone

W perlu, sekwencja instrukcji definiująca zakres nazywana jest blokiem. Czasami ograniczeniem bloku stanowi zawierający go plik (w wypadku wymaganego (required) pliku lub programu jako całości), a czasami zasięg łańcucha znakowego (w wypadku eval).

Lecz ogólnie, blok jest ograniczony nawiasami klamrowymi. Taką konstrukcję syntaktyczną nazwiemy BLOKIEM.

Do kontroli przepływu można używać następujących instrukcji złożonych:

    if (WYRAŻ) BLOK
    if (WYRAŻ) BLOK else BLOK
    if (WYRAŻ) BLOK elsif (WYRAŻ) BLOK ... else BLOK
    ETYKIETA while (WYRAż) BLOK
    ETYKIETA while (WYRAŻ) BLOK continue BLOK
    ETYKIETA for (WYRAŻ; WYRAŻ; WYRAŻ) BLOK
    ETYKIETA foreach VAR (LISTA) BLOK
    ETYKIETA BLOK continue BLOK

    if (!open(FOO)) { die "Can't open $FOO: $!"; }
    die "Can't open $FOO: $!" unless open(FOO);
    open(FOO) or die "Can't open $FOO: $!";     # FOO lub giń!
    open(FOO) ? 'hi mom' : die "Can't open $FOO: $!";
                        # to ostatnie trochę egzotyczne

Instrukcja while wykonuje swój blok tak długo, jak wyrażenie jest prawdziwe (jego wartością nie jest łańcuch pusty, 0 czy "0"). ETYKIETA jest opcjonalna, a jeśli jest obecna, składa się z identyfikatora, za którym następuje dwukropek. ETYKIETA identyfikuje pętlę dla instrukcji kontroli pętli, czyli next, last i redo. Jeśli pominięto ETYKIETĘ, instrukcje kontroli pętli odnoszą się do najbardziej wewnętrznej otaczającej pętli. Może to wymagać dynamicznego przeglądania wstecz stosu wywołań w czasie wykonania, aby znaleźć odpowiednią ETYKIETĘ. Takie desperackie zachowania dają zwykle ostrzeżenia przy włączonej fladze -w.

Jeśli istnieje BLOK continue, to jest on zawsze wykonywany tuż przed kolejną analizą warunku, podobnie jak trzeci element pętli for w C. Można tego używać do zwiększania zmiennej sterującej pętli, nawet gdy pętla jest właśnie kontynuowana instrukcją next (która jest z kolei podobna do instrukcji continue z C).

Kontrola pętli

Polecenie next jest podobne do instrukcji continue z C; rozpoczyna nową iterację pętli:

    LINE: while (<STDIN>) {
        next LINE if /^#/;      # wykasuj komentarze
        ...
    }

    LINE: while (<STDIN>) {
        last LINE if /^$/;      # zakończ po obsłużeniu nagłówka
        ...
    }

Na przykład, podczas przetwarzania pliku takiego, jak /etc/termcap. Jeśli twoje wiersze wejściowe mogą się kończyć lewymi ukośnikami, wskazującymi kontynuację, możesz chcieć z wyprzedzeniem pobrać następny rekord.

    while (<>) {
        chomp;
        if (s/\\$//) {
            $_ .= <>;
            redo unless eof();
        }
        # teraz przetwórz $_
    }

    LINE: while (defined($line = <ARGV>)) {
        chomp($line);
        if ($line =~ s/\\$//) {
            $line .= <ARGV>;
            redo LINE unless eof(); # nie eof(ARGV)!
        }
        # teraz przetwórz $line
    }

    LINE: while (<STDIN>) {
        while (s⎪({.*}.*){.*}⎪$1 ⎪) {}
        s⎪{.*}⎪ ⎪;
        if (s⎪{.*⎪ ⎪) {
            $front = $_;
            while (<STDIN>) {
                if (/}/) {      # koniec komentarza?
                    s⎪^⎪$front{⎪;
                    redo LINE;
                }
            }
        }
        print;
    }

    # zainspirowane przez :1,$g/fred/s//WILMA/
    while (<>) {
       ?(fred)?     && s//WILMA $1 WILMA/;
       ?(barney)?   && s//BETTY $1 BETTY/;
       ?(homer)?    && s//MARGE $1 MARGE/;
    } continue {
       print "$ARGV $.: $_";
       close ARGV   if eof();    # reset $. (nr wiersza)
       reset        if eof();    # reset ?wzorca?
    }

Instrukcje sterujące pętli nie współpracują z if ani unless, gdyż nie są one pętlami. Możesz jednak podwoić nawiasy by je nimi uczynić.

    if (/wzorzec/) {{
       next if /fred/;
       next if /barney/;
       # coś tu robi
    }}
Postać while/if BLOCK BLOCK, która była dostępna w Perl 4 nie jest
już prawidłowa. Zmień wszystkie wystąpienia
if BLOCK na if (do BLOCK).

Pętle for

Perlowa pętla for w stylu C, działa dokładnie jak odpowiadająca jej
pętla while, co znaczy, że to:

    for ($i = 1; $i < 10; $i++) {
        ...
    }

    $i = 1;
    while ($i < 10) {
        ...
    } continue {
        $i++;
    }

Poza zwykłymi pętlami po indeksach tablic, for daje wiele innych zastosowań. Oto przykład, zapobiegający problemowi, który napotyka się testując jawnie EOF na interaktywnym deskryptorze pliku, co powoduje, że program wygląda jakby się zawiesił.

    $on_a_tty = -t STDIN && -t STDOUT;
    sub prompt { print "yes? " if $on_a_tty }
    for ( prompt(); <STDIN>; prompt() ) {
        # zrób coś
    }

Pętle foreach

Pętla foreach iteruje poprzez normalną wartość listową i przypisuje zmiennej VAR wartość każdego kolejnego elementu listy. Jeśli zmienna jest poprzedzona słowem kluczowym my, to jest ona leksykalnie zawężona i widzialna tylko wewnątrz pętli. W przeciwnym wypadku, zmienna jest niejawnie lokalna w pętli i, po wyjściu z niej, odzyskuje pierwotną wartość. Jeśli zmienna była poprzednio zadeklarowana przez my, to pętla używa tej zmiennej, zamiast zmiennej globalnej, lecz wciąż jest ona lokalna w obrębie pętli. (Zauważ, że zmienne o zasięgu leksykalnym mogą być przyczyną kłopotów, jeśli wewnątrz pętli masz odwołujące się do nich procedury lub deklaracje formatów.)

Słowo kluczowe foreach jest w rzeczywistości synonimem słowa for, więc foreach możesz używać dla czytelności, a for dla skrócenia. (Albo też powłoka Bourne'a jest Ci milsza niż csh, więc pisanie for jest naturalniejsze.) Jeśli VAR jest pominięte, na kolejne wartości ustawiane będzie $_. Jeśli dowolny element LISTY jest lwartością, to możesz łatwo modyfikować jego wartość, modyfikując VAR wewnątrz pętli. Jest tak dlatego, że zmienna indeksu pętli foreach jest niejawnym synonimem każdego iterowanego elementu. W szczególności możliwa jest zmiana tym sposobem wartości elementów tablicy LISTA (ale nie wyrażenia zwracającego LISTĘ).

Jeśli dowolna część LISTY jest tablicą, to foreach bardzo się zmiesza, jeśli wewnątrz pętli dodasz lub usuniesz elementy, na przykład przy pomocy splice. Nie rób więc tego.

foreach prawdopodobnie nie zrobi tego, czego oczekujesz, jeśli VAR jest zmienną specjalną. Tego też nie rób.

Przykłady:

    for (@ary) { s/foo/bar/ }

    foreach my $elem (@elements) {
        $elem *= 2;
    }

    for $count (10,9,8,7,6,5,4,3,2,1,'BOOM') {
        print $count, "\n"; sleep(1);
    }

    for (1..15) { print "Merry Christmas\n"; }

    foreach $item (split(/:[\\\n:]*/, $ENV{TERMCAP})) {
        print "Item: $item\n";
    }

    for (my $i = 0; $i < @ary1; $i++) {
        for (my $j = 0; $j < @ary2; $j++) {
            if ($ary1[$i] > $ary2[$j]) {
                last; # nie mogę wyjść do zewnętrznej :-(
            }
            $ary1[$i] += $ary2[$j];
        }
        # tu zabiera mnie last
    }

    OUTER: foreach my $wid (@ary1) {
    INNER:   foreach my $jet (@ary2) {
                next OUTER if $wid > $jet;
                $wid += $jet;
             }
          }

Podstawowe instrukcje BLOKOWE i switch

BLOK (z etykietą lub bez) jest równoważny pętli, która jest wykonywana jeden raz. Tak więc możesz wewnątrz używać instrukcji kontroli pętli by wyjść z bloku lub ponowić jego wykonanie. (Zauważ, że nie jest to prawdą wewnątrz eval{}, sub{} czy, przeciwnie do rozpowszchnionych przekonań, bloków do{}, które nie zaliczają się do pętli.) Blok continue jest opcjonalny.

Konstrukcja BLOKU jest szczególnie wygodna do tworzenia struktur wyboru (case).

    SWITCH: {
        if (/^abc/) { $abc = 1; last SWITCH; }
        if (/^def/) { $def = 1; last SWITCH; }
        if (/^xyz/) { $xyz = 1; last SWITCH; }
        $nothing = 1;
    }

    SWITCH: {
        $abc = 1, last SWITCH  if /^abc/;
        $def = 1, last SWITCH  if /^def/;
        $xyz = 1, last SWITCH  if /^xyz/;
        $nothing = 1;
    }

lub

    SWITCH: {
        /^abc/ && do { $abc = 1; last SWITCH; };
        /^def/ && do { $def = 1; last SWITCH; };
        /^xyz/ && do { $xyz = 1; last SWITCH; };
        $nothing = 1;
    }

    SWITCH: {
        /^abc/      && do {
                            $abc = 1;
                            last SWITCH;
                       };

        /^def/      && do {
                            $def = 1;
                            last SWITCH;
                       };

        /^xyz/      && do {
                            $xyz = 1;
                            last SWITCH;
                        };
        $nothing = 1;
    }

    SWITCH: {
        /^abc/ and $abc = 1, last SWITCH;
        /^def/ and $def = 1, last SWITCH;
        /^xyz/ and $xyz = 1, last SWITCH;
        $nothing = 1;
    }

    if (/^abc/)
        { $abc = 1 }
    elsif (/^def/)
        { $def = 1 }
    elsif (/^xyz/)
        { $xyz = 1 }
    else
        { $nothing = 1 }

    SWITCH: for ($where) {
                /In Card Names/     && do { push @flags, '-e'; last; };
                /Anywhere/          && do { push @flags, '-h'; last; };
                /In Rulings/        && do {                    last; };
                die "unknown value for form variable where: `$where'";
            }

    $amode = do {
        if     ($flag & O_RDONLY) { "r" }
        elsif  ($flag & O_WRONLY) { ($flag & O_APPEND) ? "a" : "w" }
        elsif  ($flag & O_RDWR)   {
            if ($flag & O_CREAT)  { "w+" }
            else                  { ($flag & O_APPEND) ? "a+" : "r+" }
        }
    };

        print do {
            ($flags & O_WRONLY) ? "write-only"          :
            ($flags & O_RDWR)   ? "read-write"          :
                                  "read-only";
        };

    #!/usr/bin/perl 
    # dobierz plik ze stroną żargonu według przeglądarki
    $dir = 'http://www.wins.uva.nl/~mes/jargon';
    for ($ENV{HTTP_USER_AGENT}) { 
        $page  =    /Mac/            && 'm/Macintrash.html'
                 ⎪⎪ /Win(dows )?NT/  && 'e/evilandrude.html'
                 ⎪⎪ /Win⎪MSIE⎪WebTV/ && 'm/MicroslothWindows.html'
                 ⎪⎪ /Linux/          && 'l/Linux.html'
                 ⎪⎪ /HP-UX/          && 'h/HP-SUX.html'
                 ⎪⎪ /SunOS/          && 's/ScumOS.html'
                 ⎪⎪                     'a/AppendixB.html';
    }
    print "Location: $dir/$page\015\012\015\012";

Możesz także rozważyć napisanie hasza (tablicy asocjacyjnej) zamiast syntezowania instrukcji switch.

Goto

Perl obsługuje instrukcję goto. ETYKIETA pętli nie jest w rzeczywistości prawidłowym celem goto; jest tylko nazwą pętli. Istnieją trzy postacie: goto-ETYKIETA, goto-WYRAŻ i goto-&NAZWA.

Postać goto-ETYKIETA szuka instrukcji oznaczonej ETYKIETĄ i kontynuuje wykonywanie w tym miejscu. Nie może być używana do wchodzenia do wnętrza konstrukcji, które wymagają inicjalizacji, takich jak procedury lub pętle foreach. Nie może też być używana do wchodzenia do konstrukcji, które są w jakiś sposób optymalizowane. Może być używane do wchodzenia prawie we wszystkie inne miejsca w zakresie dynamicznym, łącznie z wychodzeniem z procedur, lecz zwykle lepiej jest użyć konstrukcji takiej jak last lub die. Autor Perla nigdy nie czuł potrzeby używania tej postaci goto (w Perlu--C to inna sprawa).

Postać goto-WYRAŻ oczekuje nazwy etykiety, której zakres zostanie rozwiązany dynamicznie. Umożliwia to stosowanie wyliczanych goto jak w FORTRANie, lecz nie jest zbyt zalecane jeśli optymalizujesz z uwagi na konserwację programu:

    goto ("FOO", "BAR", "GLARCH")[$i];

W większości tego typu przypadków, zazwyczaj dużo, dużo lepszym pomysłem jest używanie strukturalnych mechanizmów kontroli przepływu next, last lub redo, zamiast zwracać się ku goto. Dla niektórych zastosowań, para eval{} i die(), służąca do przetwarzania wyjątków może być też rozsądnym wyjściem.

POD: Osadzona dokumentacja

Perl posiada mechanizm łączenia dokumentacji z kodem źródłowym. Podczas oczekiwania początku nowej instrukcji, jeśli kompilator natrafi na linię, rozpoczynającą się od znaku równości i słowa, jak

    =head1 Here There Be Pods!

Umożliwia ci to łączenie kodu źródłowego i dokumentacji, jak w

    =item snazzle($)

    Funkcja snazzle() będzie zachowywać się w najbardziej spektakularny
    sposób, jaki możesz sobie wyobrazić, prześcigając nawet cyber
    pirotechnikę.

    =cut powrót do kompilatora, fora z tego pod-fora!

    sub snazzle($) {
        my $thingie = shift;
        .........
    }

    $a=3;
    =tajne rzeczy
     warn "Ani POD ani KOD!?"
    =cut powrot
    print "got $a\n";

Dyrektyw pod można też używać do szybkiego wykomentowania sekcji kodu.

Plain Old Comments (Nie!)

Podobnie jak preprocesor C, perl może przetwarzać dyrektywy liniowe. Przy ich użyciu, można kontrolować perlowe pojęcie nazw plików i numerów linii w komunikatach o błędach/ostrzeżeniach (szczególnie dla łańcuchów, które są przetwarzane z eval()). Składnia tego mechanizmu jest taka sama dla jak dla większości preprocesorów C: dopasowuje wyrażenie regularne /^#\s*line\s+(\d+)\s*(?:\s"([^"]*)")?/ do $1, będącego numerem linii i $2, będącego opcjonalną nazwą pliku (podaną w cudzysłowach).

Oto niektóre przykłady, które możesz sprawdzić w swojej powłoce:

    % perl
    # line 200 "bzzzt"
    # znak `#' w poprzedniej linii musi być pierwszym znakiem linii
    die 'foo';
    __END__
    foo at bzzzt line 201.

    % perl
    # line 200 "bzzzt"
    eval qq[\n#line 2001 ""\ndie 'foo']; print $@;
    __END__
    foo at - line 2001.

    % perl
    eval qq[\n#line 200 "foo bar"\ndie 'foo']; print $@;
    __END__
    foo at foo bar line 200.

    % perl
    # line 345 "goop"
    eval "\n#line " . __LINE__ . ' "' . __FILE__ ."\"\ndie 'foo'";
    print $@;
    __END__
    foo at goop line 345.